#include<stdio.h>

typedef struct treeNode
{
  #define size 3
  int n;//n[x], the number of keys currently stored in node x,
  
  int array[size]; //the n[x] keys themselves, stored in nondecreasing order, so that key1[x] <= key2[x] <= ... <= key(n[x])[x],
  
  int isLeaf;//leaf [x], a boolean value that is TRUE if x is a leaf and FALSE if x is an internal node.
  
  struct treeNode *p[size + 1];//Each internal node x also contains n[x]+ 1 pointers c1[x], c2[x], ..., cn[x]+1[x] to its children. Leaf nodes have no children, so their ci fields are undefined.
  
  //3. The keys keyi[x] separate the ranges of keys stored in each subtree: if ki is any key stored in the subtree with root ci [x], then k1 <= key1[x] <= k2 <= key2[x] <= ... <= key(n[x])[x] <= k(n[x]+1).
  //4. All leaves have the same depth, which is the tree's height h.
  /*
    There are lower and upper bounds on the number of keys a node can contain. These bounds can be expressed in terms of a fixed integer t >= 2 called the minimum degree of the B-tree:
    Every node other than the root must have at least t - 1 keys. Every internal node other than the root thus has at least t children. If the tree is nonempty, the root must have at least one key.
    Every node can contain at most 2t - 1 keys. Therefore, an internal node can have at most 2t children. We say that a node is full if it contains exactly 2t - 1 keys.[1] 
   */
}BTree;

void B_TREE_CREATE(BTree *root);
void DISK_WRITE(BTree *root);

void NewBTreeNode();

int main() 
{ 
  
  return 0; 
}

void B_TREE_CREATE(BTree *root)
{
  
}

void NewBTreeNode()
{
  
}

void DISK_WRITE(BTree *root)
{
  //Do nothing here
}
